﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Newtonsoft.Json;
using System.Net;
using System.IO;
using System.ComponentModel;
using AppCommerciaux.ViewModels;
using Newtonsoft.Json;
using System.Globalization;

namespace AppCommerciaux.Views
{
    /// <summary>
    /// Logique d'interaction pour UserControlSynchro.xaml
    /// </summary>
    public partial class UserControlSynchro : UserControl
    {
        AccueilPrincipalView apv;
        private SynchroViewModel _viewModel;
        private string APIURL = "http://www.ril13.fr/web/app_dev.php/api/";
        //private string APIURL = "http://localhost/SFRIL13/web/app_dev.php/api/";
        private BackgroundWorker bwSynchroReception = null;
        private BackgroundWorker bwSynchroEnvoi = null;


        #region Constructeurs
        public UserControlSynchro()
        {
            InitializeComponent();
            lstviewSynchro.Items.Clear();
        }

        public UserControlSynchro(AccueilPrincipalView apv)
        {
            InitializeComponent();
            this.apv = apv;
            lstviewSynchro.Items.Clear();
        }

        public UserControlSynchro(SynchroViewModel ViewModel, AccueilPrincipalView apv)
        {
            InitializeComponent();
            this.apv = apv;
            lstviewSynchro.Items.Clear();
            DataContext = _viewModel = ViewModel;
        }
        #endregion

        #region boutons
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            MessageBoxResult result = MessageBox.Show("La synchronisation va envoyer vos données, puis vider la base locale pour réceptionner les données. Voulez vous continuer", "Synchronisation des données", MessageBoxButton.YesNo, MessageBoxImage.Information);
            if (result == MessageBoxResult.Yes)
            {
                this._viewModel.EnableButtonReception = false;
                this.apv.textProgressBarFooter.Inlines.Clear();
                this.apv.textProgressBarFooter.Inlines.Add("Synchronisation des données WebService ...");

                launchSynchroReception();
            }
        }
        


        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            /*
            MessageBoxResult result = MessageBox.Show("Ceci va envoyer vos données sur le système central, voulez vous continuer ?", "Envoi des données", MessageBoxButton.YesNo, MessageBoxImage.Information);
            if (result == MessageBoxResult.Yes)
            {
                this._viewModel.EnableButtonReception = false;
                this.apv.textProgressBarFooter.Inlines.Clear();
                this.apv.textProgressBarFooter.Inlines.Add("Envoi des données WebService ...");

                launchSynchroEnvoi();
            }
            */
        }
        #endregion

        #region methodes
        private void launchSynchroEnvoi()
        {
            //-> Lancement réception en Bakground Worker
            bwSynchroEnvoi = new BackgroundWorker();

            bwSynchroEnvoi.WorkerReportsProgress = true;
            bwSynchroEnvoi.DoWork += bwSynchroEnvoi_DoWork;
            bwSynchroEnvoi.RunWorkerCompleted += bwSynchroEnvoi_RunWorkerCompleted;
            bwSynchroEnvoi.ProgressChanged += bwSynchroEnvoi_ProgressChanged;
            bwSynchroEnvoi.RunWorkerAsync();

        }

        private void launchSynchroReception()
        {
            //-> Lancement réception en Bakground Worker
            bwSynchroReception = new BackgroundWorker();
            bwSynchroReception.WorkerReportsProgress = true;
            bwSynchroReception.DoWork += bwSynchroReception_DoWork;
            bwSynchroReception.RunWorkerCompleted += bwSynchroReception_RunWorkerCompleted;
            bwSynchroReception.ProgressChanged += bwSynchroReception_ProgressChanged;
            bwSynchroReception.RunWorkerAsync();

        }
        #endregion

        #region background worker envoi (inutilisé)
        void bwSynchroEnvoi_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            lstviewSynchro.Items.Add(e.UserState);

            this.apv.progressBarFooter.Value = e.ProgressPercentage;
        }

        void bwSynchroEnvoi_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {

            this.apv.textProgressBarFooter.Inlines.Clear();
            this.apv.textProgressBarFooter.Inlines.Add("Synchronisation terminée");
            MessageBox.Show("Envoi des données terminée", "Synchronisation terminée", MessageBoxButton.OK, MessageBoxImage.Information);
            this._viewModel.EnableButtonReception = true;
            this.apv.textProgressBarFooter.Inlines.Clear();
            this.apv.progressBarFooter.Value = 0;


        }

        void bwSynchroEnvoi_DoWork(object sender, DoWorkEventArgs e)
        {
            using (Entity.liv3Entities1 dc = new Entity.liv3Entities1())
            {
                //-> Construction de l'URL de l'API (voir pour mettre la variable APIURL dans un fichier de config externe à l'application)
                string Url = null;
                WebRequest webRequest = null;
                WebResponse response = null;
                Stream responseStream = null;
                StreamReader reader = null;
                string responseFromServer = null;
                ItemForListViewSnchro itemToAdd = null;
                byte[] byteArray = null;

                /*
                 * ----------------------------------------------------------------------
                 * 
                 * Envoi des données
                 * 
                 * ----------------------------------------------------------------------
                 */


                List<Entity.commandeclient> allNewCommande = null;
                //-> création d'une jeux de données pour le test (à supprimer à l'avenir)
                /*
                dc.Database.ExecuteSqlCommand("DELETE FROM commandeclient");
                dc.Database.ExecuteSqlCommand("DELETE FROM lignecommandeclient");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='commandeclient';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='lignecommandeclient';");
                Entity.commandeclient myCommandeclient = new Entity.commandeclient { id = 1, dateCreation = "2015-03-24T08:40:17+0100", statut = 1, totalHT = 100, totalTTC = (decimal)120.60, montantTva = (decimal)20.6, id_tiers_societe = 40, id_tiers_contact = 6, synchro = "N" };
                Entity.lignecommandeclient myLigneCommandeclient = new Entity.lignecommandeclient { id = 1, id_produit = 11, id_commandeclient = 1, puHT = (decimal)10.20, quantite = (decimal)5, tauxTva = (decimal)20.6, totalHT = (decimal)100.3, totalTTC = (decimal)125.6, synchro = "N" };
                dc.commandeclient.Add(myCommandeclient);
                dc.lignecommandeclient.Add(myLigneCommandeclient);
                dc.SaveChanges();
                 * */
                //-> fin réation d'un jeux de données pour le test


                //-> Nouvelles commandes
                allNewCommande = new List<Entity.commandeclient>();
                allNewCommande = dc.commandeclient.Where(f => f.synchro == "N").ToList();
                foreach (Entity.commandeclient myCommande in allNewCommande)
                {
                    // La liste des lignes de commande sérialisé en JSON
                    string jsonLigneCommande = JsonConvert.SerializeObject(myCommande.lignecommandeclient.ToList(), Formatting.Indented);

                    // Appel de l'API
                    Url = APIURL + "commandes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    string postData = "commandeDateCreation=" + DateTime.Parse(myCommande.dateCreation).ToString("yyyy-MM-dd") +
                                        "&commandeStatus=" + myCommande.statut.ToString() +
                                        "&commandeTotalHT=" + myCommande.totalHT.ToString().Replace(",", ".") +
                                        "&commandeTotalTTC=" + myCommande.totalTTC.ToString().Replace(",", ".") +
                                        "&commandeMontantAcompte=" + myCommande.montantAcompte.ToString().Replace(",", ".") +
                                        "&commandeMontantTVA=" + myCommande.montantTva.ToString().Replace(",", ".") +
                                        "&commandeMontantRemise=" + myCommande.montantRemise.ToString().Replace(",", ".") +
                                        "&commandeIdSociete=" + myCommande.id_tiers_societe +
                                        "&commandeIdContact=" + myCommande.id_tiers_contact +
                                        "&commandeLignesCommande=" + jsonLigneCommande
                                        ;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        responseStream.Close();
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du client pour afficher dans les logs
                        //Entity.tiers_societe mySociete = dc.tiers_societe.Where(s => s.id == myCommande.id_tiers_societe).FirstOrDefault();
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString() + " | Client : " + mySociete.raisonSociale, Status = "success" };

                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "[ERROR] id : " + myCommande.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroEnvoi.ReportProgress(5, itemToAdd);


            }
        }
        #endregion

        #region background worker reception (qui fait aussi envoi)
        void bwSynchroReception_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            if (e.UserState != null)
            {
                lstviewSynchro.Items.Add(e.UserState);
            }
            

            this.apv.progressBarFooter.Value = e.ProgressPercentage;
        }

        void bwSynchroReception_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            this.apv.textProgressBarFooter.Inlines.Clear();
            this.apv.textProgressBarFooter.Inlines.Add("Synchronisation terminée");
            MessageBox.Show("Synchronisation des données terminée", "Synchronisation terminée", MessageBoxButton.OK, MessageBoxImage.Information);
            this._viewModel.EnableButtonReception = true;
            this.apv.textProgressBarFooter.Inlines.Clear();
            this.apv.progressBarFooter.Value =0;
        }

        void bwSynchroReception_DoWork(object sender, DoWorkEventArgs e)
        {
            //-> Construction de l'URL de l'API (voir pour mettre la variable APIURL dans un fichier de config externe à l'application)
            string Url = null;
            WebRequest webRequest = null;
            WebResponse response = null;
            Stream responseStream = null;
            StreamReader reader = null;
            string responseFromServer = null;
            ItemForListViewSnchro itemToAdd = null;
            byte[] byteArray = null;
            string postData = null;

            using (Entity.liv3Entities1 dc = new Entity.liv3Entities1())
            {




                /*
                 * ----------------------------------------------------------------------
                 * 
                 * Envoi des données
                 * 
                 * ----------------------------------------------------------------------
                 */


                List<Entity.commandeclient> allNewCommande = null;
                List<Entity.commandeclient> allDeleteCommande = null;
                List<Entity.lignecommandeclient> allNewCommandeLine = null;
                List<Entity.lignecommandeclient> allModifCommandeLine = null;
                List<Entity.lignecommandeclient> allDeleteCommandeLine = null;
                List<Entity.tiers_societe> allModifSociete = null;

                //-> création d'une jeux de données pour le test (à supprimer à l'avenir)
                // Jeux de données nouvelle commande
                /*
                dc.Database.ExecuteSqlCommand("DELETE FROM commandeclient");
                dc.Database.ExecuteSqlCommand("DELETE FROM lignecommandeclient");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='commandeclient';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='lignecommandeclient';");
                Entity.commandeclient myCommandeclient = new Entity.commandeclient { id = 1, dateCreation = "2015-03-24T08:40:17+0100", statut = 1, totalHT = 100, totalTTC = (decimal)120.60, montantTva = (decimal)20.6, id_tiers_societe = 40, id_tiers_contact = 6, synchro = "N" };
                Entity.lignecommandeclient myLigneCommandeclient = new Entity.lignecommandeclient { id = 1, id_produit = 11, id_commandeclient = 1, puHT = (decimal)10.20, quantite = (decimal)5, tauxTva = (decimal)20.6, totalHT = (decimal)100.3, totalTTC = (decimal)125.6};
                dc.commandeclient.Add(myCommandeclient);
                dc.lignecommandeclient.Add(myLigneCommandeclient);
                dc.SaveChanges();
                */
                

                // Jeux de données nouvelle ligne d'une commande
                /*
                Entity.lignecommandeclient myLigneCommandeclient = new Entity.lignecommandeclient { id = 3, id_produit = 11, id_commandeclient = 25, puHT = (decimal)10.20, quantite = (decimal)5, tauxTva = (decimal)20.6, totalHT = (decimal)100.3, totalTTC = (decimal)125.6, synchro = "N" };
                dc.lignecommandeclient.Add(myLigneCommandeclient);
                dc.SaveChanges();
                */

                // Jeux de données ligne de commande mise à jour
                /*
                Entity.lignecommandeclient myLigneCommandeclient = dc.lignecommandeclient.Where(s => s.id == 68).FirstOrDefault();
                myLigneCommandeclient.totalHT = (decimal)56.23;
                myLigneCommandeclient.synchro = "M";
                dc.SaveChanges();
                */

                // Jeux de données ligne de commande à supprimer
                /*
                Entity.lignecommandeclient myLigneCommandeclient = dc.lignecommandeclient.Where(s => s.id == 26).FirstOrDefault();
                myLigneCommandeclient.synchro = "D";
                dc.SaveChanges();
                */

                // Jeux de données  de commande à supprimer
                /*
                Entity.commandeclient myCommandeclient = dc.commandeclient.Where(s => s.id == 23).FirstOrDefault();
                myCommandeclient.synchro = "D";
                dc.SaveChanges();
                */
                //-> fin réation d'un jeux de données pour le test


                //-> Nouvelles commandes
                allNewCommande = new List<Entity.commandeclient>();
                allNewCommande = dc.commandeclient.Where(f => f.synchro == "N").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de commande + ligne", Observation = "Aucune nouvelle commande à envoyer", Status = "nothing" };
                foreach (Entity.commandeclient myCommande in allNewCommande)
                {
                    // La liste des lignes de commande sérialisé en JSON
                    string jsonLigneCommande = JsonConvert.SerializeObject(myCommande.lignecommandeclient.ToList(), Formatting.Indented);

                    // Appel de l'API
                    Url = APIURL + "commandes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "commandeDateCreation=" + DateTime.Parse(myCommande.dateCreation).ToString("yyyy-MM-dd") +
                                        "&commandeStatus=" + myCommande.statut.ToString() +
                                        "&commandeTotalHT=" + myCommande.totalHT.ToString().Replace(",", ".") +
                                        "&commandeTotalTTC=" + myCommande.totalTTC.ToString().Replace(",", ".") +
                                        "&commandeMontantAcompte=" + myCommande.montantAcompte.ToString().Replace(",", ".") +
                                        "&commandeMontantTVA=" + myCommande.montantTva.ToString().Replace(",", ".") +
                                        "&commandeMontantRemise=" + myCommande.montantRemise.ToString().Replace(",", ".") +
                                        "&commandeIdSociete=" + myCommande.id_tiers_societe +
                                        "&commandeIdContact=" + myCommande.id_tiers_contact +
                                        "&commandeLignesCommande=" + jsonLigneCommande
                                        ;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du client pour afficher dans les logs
                        Entity.tiers_societe mySociete = dc.tiers_societe.Where(s => s.id == myCommande.id_tiers_societe).FirstOrDefault();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString() + " | Client : " + mySociete.raisonSociale, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de commande + ligne", Observation = "[ERROR] id : " + myCommande.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(5, itemToAdd);

                //-> Nouvelles lignes
                allNewCommandeLine = new List<Entity.lignecommandeclient>();
                allNewCommandeLine = dc.lignecommandeclient.Where(f => f.synchro == "N").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de ligne de commande", Observation = "Aucune nouvelle ligne de commande (d'une commande précédemment synchronisée)", Status = "nothing" };
                foreach (Entity.lignecommandeclient myCommandeLine in allNewCommandeLine)
                {
                    // La liste des lignes de commande sérialisé en JSON
                    string jsonLigneCommande = JsonConvert.SerializeObject(myCommandeLine, Formatting.Indented);

                    // Appel de l'API
                    Url = APIURL + "lignecommandes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "commandeId=" + myCommandeLine.id_commandeclient +
                                        "&commandeLignesCommande=" + jsonLigneCommande
                                        ;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du produit pour afficher dans les logs
                        Entity.produit myProduit = dc.produit.Where(s => s.id == myCommandeLine.id_produit).FirstOrDefault();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de ligne de commande", Observation = "Montant : " + myCommandeLine.totalTTC.ToString() + " | Produit : " + myProduit.libelle, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Création de ligne de commande", Observation = "[ERROR] id : " + myCommandeLine.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(10, itemToAdd);


                //-> Lignes modifiées
                allModifCommandeLine = new List<Entity.lignecommandeclient>();
                allModifCommandeLine = dc.lignecommandeclient.Where(f => f.synchro == "M").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de ligne de commande", Observation = "Aucune ligne de commande modifiée (d'une commande précédemment synchronisée)", Status = "nothing" };
                foreach (Entity.lignecommandeclient myCommandeLine in allModifCommandeLine)
                {

                    // Appel de l'API
                    Url = APIURL + "lignecommande";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "PUT";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "ligneCommandeId=" + myCommandeLine.id +
                               "&ligneCommandeIdProduit=" + myCommandeLine.id_produit +
                               "&ligneCommandeTotalHT=" + myCommandeLine.totalHT.ToString().Replace(",", ".") +
                               "&ligneCommandePuHT=" + myCommandeLine.puHT.ToString().Replace(",", ".") +
                               "&ligneCommandQuantite=" + myCommandeLine.quantite.ToString().Replace(",", ".") +
                               "&ligneCommandTauxTVA=" + myCommandeLine.tauxTva.ToString().Replace(",", ".") +
                               "&ligneCommandTotalTTC=" + myCommandeLine.totalTTC.ToString().Replace(",", ".")
                                        ;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du produit pour afficher dans les logs
                        Entity.produit myProduit = dc.produit.Where(s => s.id == myCommandeLine.id_produit).FirstOrDefault();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de ligne de commande ", Observation = "Montant : " + myCommandeLine.totalTTC.ToString() + " | Produit : " + myProduit.libelle, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de ligne de commande", Observation = "[ERROR] id : " + myCommandeLine.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(15, itemToAdd);



                //-> Lignes supprimées
                allDeleteCommandeLine = new List<Entity.lignecommandeclient>();
                allDeleteCommandeLine = dc.lignecommandeclient.Where(f => f.synchro == "D").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de ligne de commande", Observation = "Aucune ligne de commande supprimée (d'une commande précédemment synchronisée)", Status = "nothing" };
                foreach (Entity.lignecommandeclient myCommandeLine in allDeleteCommandeLine)
                {

                    // Appel de l'API
                    Url = APIURL + "lignecommande";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "DELETE";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "ligneCommandeId=" + myCommandeLine.id;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du produit pour afficher dans les logs
                        Entity.produit myProduit = dc.produit.Where(s => s.id == myCommandeLine.id_produit).FirstOrDefault();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de ligne de commande", Observation = "Montant : " + myCommandeLine.totalTTC.ToString() + " | Produit : " + myProduit.libelle, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de ligne de commande", Observation = "[ERROR] id : " + myCommandeLine.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(20, itemToAdd);


                //-> Commandes supprimées
                allDeleteCommande = new List<Entity.commandeclient>();
                allDeleteCommande = dc.commandeclient.Where(f => f.synchro == "D").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de commande", Observation = "Aucune commande à supprimer", Status = "nothing" };
                foreach (Entity.commandeclient myCommande in allDeleteCommande)
                {

                    // Appel de l'API
                    Url = APIURL + "commande";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "DELETE";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "commandeId=" + myCommande.id;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        // Récupération du produit pour afficher dans les logs
                        Entity.tiers_societe mySociete = dc.tiers_societe.Where(s => s.id == myCommande.id_tiers_societe).FirstOrDefault();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString() + " | Client : " + mySociete.raisonSociale, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Suppression de commande", Observation = "[ERROR] id : " + myCommande.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(25, itemToAdd);



                // Modification de société
                allModifSociete = new List<Entity.tiers_societe>();
                allModifSociete = dc.tiers_societe.Where(f => f.synchro == "M").ToList();
                itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de société", Observation = "Aucune société modifiée", Status = "nothing" };
                foreach (Entity.tiers_societe mySociete in allModifSociete)
                {

                    // Appel de l'API
                    Url = APIURL + "societe";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "PUT";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    // construction des données à envoyer
                    postData = "societeId=" + mySociete.id +
                               "&societeRaisonSociale=" + mySociete.raisonSociale +
                               "&societeRue=" + mySociete.rue +
                               "&societeCP=" + mySociete.cp +
                               "&societeVille=" + mySociete.ville +
                               "&societeTel=" + mySociete.tel +
                               "&societeFax=" + mySociete.fax +
                               "&societeSiret=" + mySociete.siret +
                               "&societeRemise=" + mySociete.remise
                                        ;
                    byteArray = Encoding.UTF8.GetBytes(postData);
                    try
                    {
                        // Envoi des données
                        webRequest.ContentLength = byteArray.Length;
                        responseStream = webRequest.GetRequestStream();
                        responseStream.Write(byteArray, 0, byteArray.Length);
                        // Récupération de la réponse
                        response = webRequest.GetResponse();
                        responseStream = response.GetResponseStream();
                        reader = new StreamReader(responseStream);
                        responseFromServer = reader.ReadToEnd();
                        reader.Close();
                        responseStream.Close();
                        response.Close();
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de société", Observation = "Nom : " + mySociete.raisonSociale, Status = "success" };
                        //itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Commande + ligne", Observation = "Montant : " + myCommande.totalTTC.ToString(), Status = "success" };
                    }
                    catch (Exception ex)
                    {
                        itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Envoi : Modification de société", Observation = "[ERROR] id : " + mySociete.id.ToString() + " | Message : " + ex.ToString(), Status = "error" };
                    }

                }
                bwSynchroReception.ReportProgress(28, itemToAdd);

            }
            //-> Il faut fermer ce USING sinon Entity Framework garde toujours en cache les commandes même si on vide la base SQLite



            using (Entity.liv3Entities1 dc = new Entity.liv3Entities1())
            {
                /*
                 * ----------------------------------------------------------------------
                 * 
                 * Vide base SQLite
                 * 
                 * ----------------------------------------------------------------------
                 */

                //- Truncate n'existe pas dans SQLite, on supprime les ligne ainsi que les séquences de la table "système"
                dc.Database.ExecuteSqlCommand("DELETE FROM commandeclient");
                dc.Database.ExecuteSqlCommand("DELETE FROM lignecommandeclient");
                //dc.Database.ExecuteSqlCommand("DELETE FROM stock");
                dc.Database.ExecuteSqlCommand("DELETE FROM tiers_contact");
                dc.Database.ExecuteSqlCommand("DELETE FROM tiers_societe");
                dc.Database.ExecuteSqlCommand("DELETE FROM produit");
                dc.Database.ExecuteSqlCommand("DELETE FROM tva");
                dc.Database.ExecuteSqlCommand("DELETE FROM unite");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='commandeclient';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='lignecommandeclient';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='stock';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='tiers_contact';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='tiers_societe';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='produit';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='tva';");
                dc.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='unite';");


                /*
                 * ----------------------------------------------------------------------
                 * 
                 * Réception des données
                 * 
                 * ----------------------------------------------------------------------
                 */


                /*
                 *  TIERS_SOCIETE
                */
                //-> Interrogation du service Web
                try
                {
                    Url = APIURL + "societes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.tiers_societe> societesFromJson = JsonConvert.DeserializeObject<List<Entity.tiers_societe>>(responseFromServer);
                    dc.tiers_societe.AddRange(societesFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TIERS_SOCIETE", Observation = "Nombre de lignes intégrées : " + societesFromJson.Count.ToString(), Status = "success" };
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TIERS_SOCIETE", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(30, itemToAdd);


                /*
                 *  TIERS_contact
                */
                //-> Interrogation du service Web
                try
                {
                    Url = APIURL + "contacts";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.tiers_contact> contactsFromJson = JsonConvert.DeserializeObject<List<Entity.tiers_contact>>(responseFromServer);
                    dc.tiers_contact.AddRange(contactsFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TIERS_contact", Observation = "Nombre de lignes intégrées : " + contactsFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TIERS_contact_", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(40, itemToAdd);

                /*
                 *  TVA
                */
                //-> Interrogation du service Web
                try
                {
                    Url = APIURL + "tvas";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.tva> tvaFromJson = JsonConvert.DeserializeObject<List<Entity.tva>>(responseFromServer);
                    dc.tva.AddRange(tvaFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TVA", Observation = "Nombre de lignes intégrées : " + tvaFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : TVA", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(50, itemToAdd);

                /*
                 *  UNITES
                */
                //-> Interrogation du service Web
                try 
                {
                    Url = APIURL + "unites";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.unite> uniteFromJson = JsonConvert.DeserializeObject<List<Entity.unite>>(responseFromServer);
                    dc.unite.AddRange(uniteFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : UNITES", Observation = "Nombre de lignes intégrées : " + uniteFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : UNITES", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(60, itemToAdd);

                /*
                 *  PRODUITS
                */
                //-> Interrogation du service Web
                try 
                {
                    Url = APIURL + "articles";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.produit> articlesFromJson = JsonConvert.DeserializeObject<List<Entity.produit>>(responseFromServer);
                    dc.produit.AddRange(articlesFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : PRODUITS", Observation = "Nombre de lignes intégrées : " + articlesFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : PRODUITS", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(70, itemToAdd);

                /*
                 *  STOCKS
                */
                //-> Interrogation du service Web
                /*
                try
                {
                    Url = APIURL + "stocks";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.stock> stockFromJson = JsonConvert.DeserializeObject<List<Entity.stock>>(responseFromServer);
                    dc.stock.AddRange(stockFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : STOCKS", Observation = "Nombre de lignes intégrées : " + stockFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : STOCKS", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(80, itemToAdd);
                */


                /*
                 *  COMMANDES
                */
                //-> Interrogation du service Web
                try 
                { 
                    Url = APIURL + "commandes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.commandeclient> commandesFromJson = JsonConvert.DeserializeObject<List<Entity.commandeclient>>(responseFromServer);
                    dc.commandeclient.AddRange(commandesFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : COMMANDES", Observation = "Nombre de lignes intégrées : " + commandesFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : COMMANDES", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(90, itemToAdd);

                /*
                 *  LIGNES COMMANDE
                */
                //-> Interrogation du service Web
                try
                {
                    Url = APIURL + "lignescommandes";
                    webRequest = WebRequest.Create(Url);
                    webRequest.Method = "GET";
                    webRequest.ContentType = "application/json; charset=utf-8";
                    response = webRequest.GetResponse();
                    responseStream = response.GetResponseStream();
                    reader = new StreamReader(responseStream);
                    responseFromServer = reader.ReadToEnd();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                    //-> Conversion de la chaine JSON en objet C# Entity + Sauvegarde
                    List<Entity.lignecommandeclient> ligneCommandesFromJson = JsonConvert.DeserializeObject<List<Entity.lignecommandeclient>>(responseFromServer);
                    dc.lignecommandeclient.AddRange(ligneCommandesFromJson);
                    dc.SaveChanges();
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : LIGNES COMMANDE", Observation = "Nombre de lignes intégrées : " + ligneCommandesFromJson.Count.ToString(), Status = "success" };
                    
                }
                catch (Exception ex)
                {
                    itemToAdd = new ItemForListViewSnchro { Hour = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), Entity = "Réception : LIGNES COMMANDE", Observation = "[ERROR] " + ex.ToString(), Status = "error" };
                }
                bwSynchroReception.ReportProgress(100, itemToAdd);
                


            }
        }
        #endregion



    }


    #region objet pour le listview
    public class ItemForListViewSnchro
    {
        /* 
         Pour ajouter des éléments à un listview en WPF il faut 
         - Dans le Xaml du liestview faire un binding
         - Créer une classe (cette classe ici présente) qui aura les attributs qu'on trouvera dans le listview
         - Dans le code C# faire un listview.itels.add(new objet de la classe ici présent)
         */
        public String Hour { get; set; }
        public String Entity { get; set; }
        public String Observation { get; set; }
        public String Status { get; set; }

    }
    #endregion  

}
